package com.alpha.core.utils;

import cn.hutool.core.collection.CollUtil;
import cn.hutool.core.lang.Matcher;

import java.util.*;
import java.util.function.Function;
import java.util.stream.Collectors;


/**
 * 集合相关工具类，包括数组
 *
 * @author chenruwan
 * @since 2022-01-01
 */
public class CollectionUtil {
    private CollectionUtil() {
    }

    /**
     * @see java.util.Collections#emptyList()
     */
    public static <T> List<T> emptyList() {
        return Collections.emptyList();
    }

    /**
     * @see java.util.Collections#emptyMap()
     */
    public static <K, V> Map<K, V> emptyMap() {
        return Collections.emptyMap();
    }

    /**
     * 提取对象集合中指定的字段(过滤掉null字段)
     */
    public static <T, R> List<R> extractField(Collection<T> collection, Function<T, R> extractor) {
        if (isEmpty(collection)) {
            return emptyList();
        }

        return collection.stream().map(extractor).filter(Objects::nonNull).collect(Collectors.toList());
    }

    /**
     * 集合是否为空
     */
    public static boolean isEmpty(Collection<?> collection) {
        return collection == null || collection.isEmpty();
    }

    /**
     * Map是否为空
     */
    public static boolean isEmpty(Map<?, ?> map) {
        return map == null || map.isEmpty();
    }

    /**
     * 集合是否为非空
     *
     * @param collection 集合
     * @return 是否为非空
     */
    public static boolean isNotEmpty(Collection<?> collection) {
        return !isEmpty(collection);
    }

    /**
     * @see CollUtil#count(Iterable, Matcher)
     */
    public static <T> int count(Iterable<T> iterable, Matcher<T> matcher) {
        return CollUtil.count(iterable, matcher);
    }

    /**
     * 合并 List
     */
    @SafeVarargs
    public static <T> List<T> merge(List<T>... elements) {
        List<T> union = new ArrayList<>();
        for (List<T> element : elements) {
            union.addAll(element);
        }
        return union;
    }

    /**
     * 如果提供的集合为{@code null}，返回一个不可变的默认空集合，否则返回原集合<br>
     */
    public static <T> List<T> emptyIfNull(List<T> list) {
        return (list == null) ? Collections.emptyList() : list;
    }

    /**
     * 如果提供的集合为{@code null}，返回一个不可变的默认空集合，否则返回原集合<br>
     */
    public static <T> Set<T> emptyIfNull(Set<T> set) {
        return (set == null) ? Collections.emptySet() : set;
    }
}
